var _n76;
var cc__extends = __extends;
var cc__awaiter = __awaiter;
var cc__generator = __generator;
var cc__importDefault = __importDefault;
Object.defineProperty(exports, "__esModule", {
  value: true
});
var $1$Loader = require("Loader");
var c = cc__importDefault($1$Loader);
var $1$zqcc_frameNamespace = require("zqcc_frameNamespace");
var l = cc__importDefault($1$zqcc_frameNamespace);
var $zqcc_OverallSystem = require("zqcc_OverallSystem");
var $1$ResourceLoader = require("ResourceLoader");
var p = cc__importDefault($1$ResourceLoader);
var def_soundManager = function (t) {
  function _ctor() {
    // 初始化音频管理对象
    const audioManager = t.call(this) || this;
    audioManager._managerName = "音频管理"; // 设置管理名称
    audioManager.previousMusic = undefined; // 上一音乐
    audioManager._isEnableAudio = true; // 是否启用音频
    audioManager._isEnableSound = true; // 是否启用音效
    audioManager._isVibration = true; // 是否启用震动
    audioManager._isRensheng = true; // 是否启用人声
    audioManager._isPlayMusic = false; // 是否正在播放音乐
    audioManager._isFangyan = true; // 是否启用方言
    audioManager.fangyan = -1; // 方言索引
    audioManager.pengzhuang = false; // 碰撞状态
    audioManager.toubi = -1; // 头像索引
    audioManager.shangyige = "bgm"; // 背景音乐标识
    audioManager.effectPlayTimeMap = new Map(); // 音效播放时间映射
    audioManager.audioClipCache = new Map(); // 音频剪辑缓存
    audioManager._Initialize(); // 初始化方法

    // 获取用户设置数据
    const userSettings = $zqcc_OverallSystem.sers().userSrv.getSettingData();
    audioManager._isEnableAudio = userSettings[0]; // 启用音频设置
    audioManager._isEnableSound = userSettings[1]; // 启用音效设置
    audioManager._isVibration = userSettings[2]; // 启用震动设置
    audioManager._isRensheng = userSettings[3]; // 启用人声设置
    audioManager._isFangyan = userSettings[4]; // 启用方言设置

    return audioManager; // 返回音频管理对象
  }
  cc__extends(_ctor, t);
  _ctor.prototype._Initialize = function () {
    t.prototype._Initialize.call(this);
  };
  Object.defineProperty(_ctor.prototype, "isEnableAudio", {
    get() {
      return this._isEnableAudio;
    },
    enumerable: false,
    configurable: true
  });
  Object.defineProperty(_ctor.prototype, "isEnableSound", {
    get() {
      return this._isEnableSound;
    },
    enumerable: false,
    configurable: true
  });
  Object.defineProperty(_ctor.prototype, "isVibration", {
    get() {
      return this._isVibration;
    },
    enumerable: false,
    configurable: true
  });
  Object.defineProperty(_ctor.prototype, "isRensheng", {
    get() {
      return this._isRensheng;
    },
    enumerable: false,
    configurable: true
  });
  Object.defineProperty(_ctor.prototype, "isPlayMusic", {
    get() {
      return this._isPlayMusic;
    },
    enumerable: false,
    configurable: true
  });
  Object.defineProperty(_ctor.prototype, "isFangyan", {
    get() {
      return this._isFangyan;
    },
    enumerable: false,
    configurable: true
  });
  _ctor.prototype.enableAudio = function (t) {
    // 确保变量 t 定义，默认值为 true
    if (undefined === t) {
      t = true;
    }

    // 设置音频启用状态
    this._isEnableAudio = t;

    // 获取用户设置数据
    const userSettings = $zqcc_OverallSystem.sers().userSrv.getSettingData();
    userSettings[0] = this._isEnableAudio; // 更新音频启用设置
    $zqcc_OverallSystem.sers().userSrv.setSettingData(userSettings); // 保存更新后的设置

    // 根据音频启用状态决定播放或停止音乐
    if (this._isEnableAudio) {
      this.playPreviousMusic(); // 播放之前的音乐
    } else {
      this.stopMusic(); // 停止音乐
      this.stopAllSound(); // 停止所有音效
    }
  };
  _ctor.prototype.enableSound = function (t) {
    // 确保变量 t 定义，默认值为 true
    if (undefined === t) {
      t = true;
    }

    // 设置音效启用状态
    this._isEnableSound = t;

    // 获取用户设置数据
    const userSettings = $zqcc_OverallSystem.sers().userSrv.getSettingData();
    userSettings[1] = this._isEnableSound; // 更新音效启用设置
    $zqcc_OverallSystem.sers().userSrv.setSettingData(userSettings); // 保存更新后的设置
  };
  _ctor.prototype.enableVibration = function (t) {
    // 确保变量 t 被定义，默认值为 true
    if (undefined === t) {
      t = true;
    }

    // 设置震动启用状态
    this._isVibration = t;

    // 获取用户设置数据
    const userSettings = $zqcc_OverallSystem.sers().userSrv.getSettingData();
    userSettings[2] = this._isVibration; // 更新震动启用设置
    $zqcc_OverallSystem.sers().userSrv.setSettingData(userSettings); // 保存更新后的设置
  };
  _ctor.prototype.enableRensheng = function (t) {
    // 确保变量 t 被定义，默认值为 true
    if (undefined === t) {
      t = true;
    }

    // 设置人声启用状态
    this._isRensheng = t;

    // 获取用户设置数据
    const userSettings = $zqcc_OverallSystem.sers().userSrv.getSettingData();
    userSettings[3] = this._isRensheng; // 更新人声启用设置
    $zqcc_OverallSystem.sers().userSrv.setSettingData(userSettings); // 保存更新后的设置
  };
  _ctor.prototype.enableFangyan = function (t) {
    // 确保变量 t 被定义，默认值为 true
    if (undefined === t) {
      t = true;
    }

    // 设置方言启用状态
    this._isFangyan = t;

    // 获取用户设置数据
    const userSettings = $zqcc_OverallSystem.sers().userSrv.getSettingData();
    userSettings[4] = this._isFangyan; // 更新方言启用设置
    $zqcc_OverallSystem.sers().userSrv.setSettingData(userSettings); // 保存更新后的设置
  };
  _ctor.prototype.getAudioClipWithSoundBundle = function (t) {
    return new Promise(function (resolve) {
      // 从音频包中加载指定的音频
      $zqcc_OverallSystem.mgrs().bundleMgr.BundleList.soundBundle.load(t, cc.AudioClip, function (error, audioClip) {
        if (error) {
          cc.log(t); // 输出音频名称
          console.error("从默认音频bundle获取音频失败"); // 输出错误信息
          return; // 结束当前函数
        }
        resolve(audioClip); // 解析成功，返回音频剪辑
      });
    });
  };
  _ctor.prototype.playSound = function (t, e, o) {
    const context = this; // 保存当前上下文
    if (undefined === e) e = false; // 设置是否循环播放的默认值
    if (undefined === o) o = 50; // 设置音效持续时间的默认值

    return new Promise(function (resolve) {
      if (context._isEnableSound) { // 检查是否启用音效
        const originalSound = t; // 保存原始音效名称
        const soundEffects = ["hu", "chi", "peng", "gang"]; // 音效列表

        // 检查音效名称是否在列表中
        if (soundEffects.indexOf(t) >= 0) {
          const additionalSetting = $zqcc_OverallSystem.sers().userSrv.getSettingData()[5] || ""; // 获取附加设置
          t += additionalSetting; // 将附加设置添加到音效名称

          // 根据附加设置确定是否添加连字符
          if (+additionalSetting === 2 && Math.random() < 0.5) {
            t += "-";
          }

          // 停止当前方言音效
          if (context.fangyan) {
            cc.log("停止上一个音效");
            cc.audioEngine.stopEffect(context.fangyan);
            context.fangyan = -1; // 重置方言
          }
        }

        // 特殊处理“投币”音效
        if (t === "投币" && context.toubi) {
          cc.audioEngine.stopEffect(context.toubi);
          context.fangyan = -1; // 重置方言
        }

        // 防止重复播放“碰撞”音效
        if (t === "pengzhuang") {
          if (context.pengzhuang) {
            return; // 如果正在播放，则直接返回
          }
          context.pengzhuang = true; // 标记为正在播放
          setTimeout(function () {
            context.pengzhuang = false; // 结束播放标记
          }, o);
        }

        // 获取音频剪辑并播放
        context.getAudioClipWithSoundBundle(t).then(function (audioClip) {
          const soundId = cc.audioEngine.playEffect(audioClip, e); // 播放音效
          if (soundEffects.indexOf(originalSound) >= 0) {
            context.fangyan = soundId; // 保存当前播放的方言音效
          }
          if (t === "投币") {
            context.toubi = soundId; // 保存投币音效的ID
          }
          resolve(soundId); // 解析 Promise
        }).catch(function () {
          console.warn(e ? "循环" : "播放" + t + "失败!!"); // 输出警告信息
        });
      }
    });
  };
  _ctor.prototype.playMusic = function (t, e) {
    const context = this; // 保存当前上下文
    if (undefined === e) e = true; // 设置默认值为 true

    // 如果正在播放音乐，停止音乐
    if (this._isPlayMusic) {
      this.stopMusic();
    }

    // 返回一个新的 Promise
    return new Promise(function (resolve) {
      // 检查是否启用音频
      if (context._isEnableAudio) {
        // 获取音频剪辑并播放
        context.getAudioClipWithSoundBundle(t).then(function (audioClip) {
          const musicId = cc.audioEngine.playMusic(audioClip, e); // 播放音乐
          context._isPlayMusic = true; // 设置为正在播放状态
          context.shangyige = t; // 保存当前音乐名称
          context.previousMusic = {
            name: t, // 当前音乐名称
            loop: e  // 是否循环
          };
          resolve(musicId); // 解析 Promise
        }).catch(function () {
          console.warn(e ? "循环" : "播放" + t + "失败!!"); // 输出警告信息
        });
      }
    });
  };
  _ctor.prototype.playBtnSound = function () {
    return this.playSound("click");
  };
  _ctor.prototype.stopMusic = function () {
    this._isPlayMusic = false;
    cc.audioEngine.stopMusic();
  };
  _ctor.prototype.stopAllSound = function () {
    cc.audioEngine.stopAllEffects();
  };
  _ctor.prototype.stopSound = function (t) {
    cc.audioEngine.stopEffect(t);
  };
  _ctor.prototype.playPreviousMusic = function () {
    // 检查是否有之前播放的音乐
    if (this.previousMusic) {
      const previousMusic = this.previousMusic;
      const musicName = previousMusic.name; // 获取音乐名称
      const isLooping = previousMusic.loop;  // 获取循环状态

      // 如果音乐名称有效，则播放之前的音乐
      if (musicName && musicName.trim() !== "") {
        this.playMusic(musicName, isLooping);
      }
    } else {
      // 如果没有之前的音乐，则播放默认的背景音乐
      this.playMusic("bgm");
    }
  };
  _ctor.prototype.getAudioClipWithSoundBundle2 = function (t, e) {
    return new Promise(function (resolve) {
      // 加载指定的 bundle
      c.default.loadBundle(e, function () {
        // 加载 bundle 中的音频目录
        c.default.loadBundleDir(e, "sound", function (audioClips) {
          // 遍历音频剪辑
          for (let index = 0; index < audioClips.length; index++) {
            const audioClip = audioClips[index];
            // 如果音频剪辑名称匹配，则解析 Promise
            if (audioClip.name === t) {
              resolve(audioClip);
            }
          }
        }, cc.AudioClip, true);
      }, true, true);
    });
  };
  _ctor.prototype.playSound2 = function (t, e, o) {
    const context = this; // 保存当前上下文

    // 确保变量 o 被定义，默认值为 false
    if (undefined === o) o = false;

    // 返回一个新的 Promise
    return new Promise(function (resolve) {
      // 检查是否启用音效
      if (context._isEnableSound) {
        // 获取音频剪辑并播放
        context.getAudioClipWithSoundBundle2(t, e).then(function (audioClip) {
          const soundId = cc.audioEngine.playEffect(audioClip, o); // 播放音效
          resolve(soundId); // 解析 Promise
        }).catch(function () {
          console.warn(o ? "循环" : "播放" + t + "失败!!"); // 输出警告信息
        });
      }
    });
  };
  _ctor.prototype.playMusic2 = function (t, e, o) {
    const context = this; // 保存当前上下文
    if (undefined === o) o = true; // 设置默认值为 true

    // 如果正在播放音乐，停止当前音乐
    if (this._isPlayMusic) {
      this.stopMusic();
    }

    // 返回一个新的 Promise
    return new Promise(function (resolve) {
      // 检查是否启用音频
      if (context._isEnableAudio) {
        // 获取音频剪辑并播放
        context.getAudioClipWithSoundBundle2(t, e).then(function (audioClip) {
          const musicId = cc.audioEngine.playMusic(audioClip, o); // 播放音乐
          context._isPlayMusic = true; // 设置正在播放状态
          context.shangyige = t; // 保存当前音乐名称
          context.previousMusic = { // 保存之前的音乐信息
            name: t,
            loop: o
          };
          resolve(musicId); // 解析 Promise
        }).catch(function () {
          console.warn(o ? "循环" : "播放" + t + "失败!!"); // 输出警告信息
        });
      }
    });
  };
  _ctor.prototype.playEffect = function (t, e, o, n) {
    // 确保变量 o 和 n 被定义，设置默认值
    if (undefined === o) o = false;
    if (undefined === n) n = -1;

    return cc__awaiter(this, undefined, undefined, function () {
      let currentTime;
      let lastPlayTime;
      let audioClipPath;
      let audioClipFullPath;
      let cachedClip;
      let soundId;

      return cc__generator(this, function (state) {
        switch (state.label) {
          case 0:
            // 检查音效是否启用
            if (this._isEnableSound) {
              currentTime = Date.now(); // 获取当前时间
              lastPlayTime = this.effectPlayTimeMap.get(t) || 0; // 获取上次播放时间

              // 判断音效播放间隔
              if (n > 0 && currentTime < lastPlayTime + 1000 * n) {
                cc.log("音效 " + t + " 间隔中，跳过播放"); // 输出日志
                return [2]; // 跳过播放
              } else {
                // 构建音效路径
                audioClipFullPath = e + "_" + (audioClipPath = "sound/" + t);
                // 检查缓存中是否已有音频剪辑
                cachedClip = this.audioClipCache.get(audioClipFullPath) ? [3, 2] : [4, p.default.getInstance().load(e, audioClipPath, cc.AudioClip)];
              }
            } else {
              return [2]; // 如果音效未启用，直接返回
            }
          case 1:
            // 加载音频剪辑
            cachedClip = state.sent();
            this.audioClipCache.set(audioClipFullPath, cachedClip); // 缓存音频剪辑
            state.label = 2; // 更新状态标签
          case 2:
            // 播放音效并记录播放时间
            soundId = cc.audioEngine.playEffect(cachedClip, o);
            this.effectPlayTimeMap.set(t, currentTime); // 更新播放时间映射
            return [2, soundId]; // 返回音效 ID
        }
      });
    });
  };
  return _ctor;
}(l.default.zqcc_ManagerBase);
exports.default = def_soundManager;